
/**
 * 不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。
 * Java提供了if和switch两种分支语句，并提供了while、do while和for三种循环语句。
 * 除此之外，JDK 5还提供了一种新的循环：foreach循环，能以更简单的方式来遍历集合、数组的元素。
 * Java还提供了break和continue来控制程序的循环结构。
 * 编译：javac -encoding UTF-8 ProcessControl.java
 * 运行：java ProcessControl
 */
public class ProcessControl {
    /**
     * if条件语句
     */
    public static void IfTest() {
        // 第一种形式 if
        int age = 30;
        if (age > 20) {
            System.out.println("年龄已经大于20岁了");
        }

        // 第二种形式 if-else
        int a = 5;
        if (a > 4) {
            System.out.println("a大于4");
        } else {
            System.out.println("a不大于4");
        }
        // 第三种形式 if-else if-...-else
        if (a > 4) {
            System.out.println("a大于4");
        } else if (a > 3) {
            ;   // 空语句
        } else {
            System.out.println("a不大于3");
        }
    }

    /**
     * switch语句由一个控制表达式和多个case标签组成，
     * 和if语句不同的是，switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型，
     * 枚举类型和java.lang.String类型（从Java 7 才允许），不能是boolean类型。
     */
    public static void SwitchTest() {
        char score = 'C';
        switch (score) {
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("中");
                break;
            case 'D':
                System.out.println("及格");
                break;
            case 'F':
                System.out.println("不及格");
                break;
            default:
                System.out.println("成绩输入错误");
        }

        /*
         * 从Java 7开始增强了switch语句的功能，允许switch语句的控制表达式是java.lang.String类型的变量或
         * 表达式—只能是java.lang.String类型，不能是StringBuffer或StringBuilder这两种字符串类型。
         */
        String season = "夏天";
        switch (season) {
            case "春天":
                System.out.println("春暖花开.");
                break;
            case "夏天":
                System.out.println("夏日炎炎.");
                break;
            case "秋天":
                System.out.println("秋高气爽.");
                break;
            case "冬天":
                System.out.println("冬雪皑皑.");
                break;
            default:
                System.out.println("季节输入错误");
        }
        /*
         * 注意：使用switch语句时，有两个值得注意的地方：
         * 第一个地方是switch语句后的expression表达式的数据类型只能是byte、short、char、int四种整数类型，
         * String（从Java 7开始支持）和枚举类型；
         * 第二个地方是如果省略了case后代码块的break;，将引入一个陷阱。
         */
    }

    /**
     * while循环每次执行循环体之前，先对test_expression循环条件求值，如果循环条件为true，则运行循环体部分。
     */
    public static void WhileTest() {
        int count = 0;
        while (count < 10) {
            System.out.println(count);
            count++;
        }
        System.out.println("while 循环结束！");
    }

    /**
     * do while循环与while循环的区别在于：
     * while循环是先判断循环条件，如果条件为真则执行循环体；
     * 而do while循环则先执行循环体，然后才判断循环条件，如果循环条件为真，则执行下一次循环，否则终止循环。
     * do-while 的循环体至少指定一次
     */
    public static void DoWhileTest() {
        int count = 1;
        do {
            System.out.println(count);
            count++;
        } while (count < 10);
        System.out.println("do-while 循环结束！");
    }

    /**
     * for循环是更加简洁的循环语句，大部分情况下，for循环可以代替while循环、do while循环。
     */
    public static void ForTest() {
        for (int count = 0; count < 10; count++) {
            System.out.println(count);
        }
        System.out.println("for 循环结束！");

        /*
         * 在上面的循环语句中，for循环的初始化语句只有一个，循环条件也只是一个简单的boolean表达式。
         * 实际上，for循环允许同时指定多个初始化语句，循环条件也可以是一个包含逻辑运算符的表达式。
         */
        for (int b = 0, s = 0, p = 0; b < 10 && s < 4 && p < 10; p++) {
            System.out.println(b++);
            System.out.println(++s + p);
        }
    }

    /**
     * 如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环，嵌套循环既可以是for循环嵌套while循环，
     * 也可以是while循环嵌套do while循环……即各种类型的循环都可以作为外层循环，也可以作为内层循环。
     */
    public static void NestedLoopTest() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("i=" + i + " j=" + j);
            }
        }
    }

    /**
     * 控制循环结构-break
     * break结束当前循环
     */
    public static void BreakTest() {
        for (int i = 0; i < 10; i++) {
            System.out.println("i的值是" + i);
            if (i == 2) {
                break;
            }
        }

        /*
         * break语句不仅可以结束其所在的循环，还可以直接结束其外层循环。
         * 此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。
         */
        outer:
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("i的值是：" + i + " j的值是：" + j);
                if (j == 1) {
                    break outer;
                }
            }
        }
    }

    /**
     * 控制循环结构-continue
     * continue的功能和break有点类似，区别是continue只是忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环；
     * 而break则是完全终止循环本身。
     */
    public static void ContinueTest() {
        for (int i = 0; i < 3; i++) {
            System.out.println("i的值是" + i);
            if (i == 1) {
                continue;
            }
            System.out.println("continue后的输出语句");
        }

        /*
         * 与break类似的是，continue后也可以紧跟一个标签，
         * 用于直接跳过标签所标识循环的当次循环的剩下语句，重新开始下一次循环。
         */
        outer:
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("i的值为：" + i + " j的值为：" + j);
                if (j == 1) {
                    continue outer;
                }
            }
        }
    }

    public static void main(String[] args) {
        IfTest();
        SwitchTest();
        WhileTest();
        DoWhileTest();
        ForTest();
        NestedLoopTest();
        BreakTest();
        ContinueTest();
    }
}
